ניהול משאבי גנרטור אסינכרוני של JavaScript: ניקוי משאבי זרם עבור יישומים חזקים

            async function* generateNumbers(count) {
  for (let i = 0; i < count; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Simulate asynchronous operation
    yield i;
  }
}

(async () => {
  for await (const number of generateNumbers(5)) {
    console.log(number);
  }
})();

            

              
                Copy
              
            
          

            async function* processStream(stream) {
  try {
    // Process the stream
    while (true) {
      const chunk = await stream.read();
      if (!chunk) break;
      yield processChunk(chunk);
    }
  } finally {
    // Cleanup code: Close the stream
    if (stream) {
      await stream.close();
      console.log('Stream closed.');
    }
  }
}

            

              
                Copy
              
            
          

            const fs = require('fs');
const { Readable } = require('stream');

async function* processFile(filePath) {
  let fileStream;
  try {
    fileStream = fs.createReadStream(filePath);
    for await (const chunk of fileStream) {
      yield chunk.toString();
    }
  } finally {
    if (fileStream) {
      fileStream.close(); // Use close for streams created by fs
      console.log('File stream closed.');
    }
  }
}

(async () => {
  const filePath = 'example.txt'; // Replace with your file path
  fs.writeFileSync(filePath, 'This is some example content.\nWith multiple lines.\nTo demonstrate stream processing.');

  for await (const line of processFile(filePath)) {
    console.log(line);
  }
})();

            

              
                Copy
              
            
          

            async function withResource(resourceFactory, generatorFunction) {
  let resource;
  try {
    resource = await resourceFactory();
    for await (const value of generatorFunction(resource)) {
      yield value;
    }
  } finally {
    if (resource) {
      await resource.cleanup();
      console.log('Resource cleaned up.');
    }
  }
}

            

              
                Copy
              
            
          

            class CustomStream {
  constructor() {
    this.data = ['Line 1', 'Line 2', 'Line 3'];
    this.index = 0;
  }

  async read() {
    await new Promise(resolve => setTimeout(resolve, 50)); // Simulate async read
    if (this.index < this.data.length) {
      return this.data[this.index++];
    } else {
      return null;
    }
  }

  async cleanup() {
    console.log('CustomStream cleanup completed.');
  }
}

async function* processCustomStream(stream) {
  while (true) {
    const chunk = await stream.read();
    if (!chunk) break;
    yield `Processed: ${chunk}`;
  }
}

async function withResource(resourceFactory, generatorFunction) {
  let resource;
  try {
    resource = await resourceFactory();
    for await (const value of generatorFunction(resource)) {
      yield value;
    }
  } finally {
    if (resource && resource.cleanup) {
      await resource.cleanup();
      console.log('Resource cleaned up.');
    }
  }
}


(async () => {
  for await (const line of withResource(() => new CustomStream(), processCustomStream)) {
    console.log(line);
  }
})();

            

              
                Copy
              
            
          

            async function* processStreamWithAbort(stream, signal) {
  try {
    while (!signal.aborted) {
      const chunk = await stream.read();
      if (!chunk) break;
      yield processChunk(chunk);
    }
  } finally {
    if (stream) {
      await stream.close();
      console.log('Stream closed.');
    }
  }
}

(async () => {
  const controller = new AbortController();
  const { signal } = controller;

  // Simulate a timeout
  setTimeout(() => {
    console.log('Aborting stream processing...');
    controller.abort();
  }, 2000);

  const stream = createSomeStream(); // Replace with your stream creation logic

  try {
    for await (const chunk of processStreamWithAbort(stream, signal)) {
      console.log('Chunk:', chunk);
    }
  } catch (error) {
    if (error.name === 'AbortError') {
      console.log('Stream processing aborted.');
    } else {
      console.error('Error processing stream:', error);
    }
  }
})();

            

              
                Copy
              
            
          

            async function* processStreamWithErrorHandling(stream) {
  try {
    while (true) {
      try {
        const chunk = await stream.read();
        if (!chunk) break;
        yield processChunk(chunk);
      } catch (error) {
        console.error('Error processing chunk:', error);
        // Optionally, you can choose to re-throw the error or continue processing
        // throw error;
      }
    }
  } finally {
    if (stream) {
      try {
        await stream.close();
        console.log('Stream closed.');
      } catch (closeError) {
        console.error('Error closing stream:', closeError);
      }
    }
  }
}

            

              
                Copy
              
            
          

            const fs = require('fs');
const cleanup = require('node-cleanup');

async function* processFile(filePath) {
  let fileStream;
  try {
    fileStream = fs.createReadStream(filePath);
    for await (const chunk of fileStream) {
      yield chunk.toString();
    }
  } finally {
    //This might not always work since the process might terminate abruptly.
    //Using try...finally in the generator itself is preferable.
  }
}


(async () => {
  const filePath = 'example.txt'; // Replace with your file path
  fs.writeFileSync(filePath, 'This is some example content.\nWith multiple lines.\nTo demonstrate stream processing.');

  const stream = processFile(filePath);
  let fileStream = fs.createReadStream(filePath);

  cleanup(function (exitCode, signal) {
        // cleanup files, delete database entries, etc
    fileStream.close();
    console.log('File stream closed by node-cleanup.');
    cleanup.uninstall(); //Uncomment to prevent calling this callback again (more info below)
    return false;
});

  for await (const line of stream) {
    console.log(line);
  }
})();

            

              
                Copy
              
            
          

            const { Pool } = require('pg');

async function* streamDataFromDatabase(query) {
  const pool = new Pool({ /* connection details */ });
  let client;
  try {
    client = await pool.connect();
    const result = await client.query(query);
    for (const row of result.rows) {
      yield row;
    }
  } finally {
    if (client) {
      client.release(); // Release the client back to the pool
      console.log('Database connection released.');
    }
    await pool.end(); // Close the pool
    console.log('Database pool closed.');
  }
}

(async () => {
  for await (const row of streamDataFromDatabase('SELECT * FROM users')) {
    console.log(row);
  }
})();

            

              
                Copy
              
            
          

            const fs = require('fs');
const csv = require('csv-parser');

async function* processCsvFile(filePath) {
  let fileStream;
  try {
    fileStream = fs.createReadStream(filePath);
    const parser = csv();
    fileStream.pipe(parser);

    for await (const row of parser) {
      yield row;
    }
  } finally {
    if (fileStream) {
      fileStream.close(); // Properly closes the stream
      console.log('CSV file stream closed.');
    }
  }
}

(async () => {
  const filePath = 'data.csv'; // Replace with your CSV file path
  fs.writeFileSync(filePath, 'header1,header2\nvalue1,value2\nvalue3,value4');

  for await (const row of processCsvFile(filePath)) {
    console.log(row);
  }
})();

            

              
                Copy
              
            
          

            const https = require('https');

async function* streamDataFromApi(url) {
  let responseStream;
  try {
    const promise = new Promise((resolve, reject) => {
      https.get(url, (res) => {
        responseStream = res;
        res.on('data', (chunk) => {
          resolve(chunk.toString());
        });

        res.on('end', () => {
          resolve(null);
        });

        res.on('error', (error) => {
          reject(error);
        });

      }).on('error', (error) => {
        reject(error);
      });
    });

    while(true) {
      const chunk = await promise; //Await the promise, it returns a chunk.
      if (!chunk) break;
      yield chunk;
    }
  } finally {
      if (responseStream && typeof responseStream.destroy === 'function') {
          responseStream.destroy();
          console.log('API stream destroyed.');
      }
  }
}

(async () => {
  // Use a public API that returns streamable data (e.g., a large JSON file)
  const apiUrl = 'https://jsonplaceholder.typicode.com/todos/1';

  for await (const chunk of streamDataFromApi(apiUrl)) {
    console.log('Chunk:', chunk);
  }
})();

            

              
                Copy